package sudroid;

import java.io.PrintStream;
import java.lang.reflect.Method;
import sudroid.java.util.Arrays;

public class LogUtils
{
  private static String TAG = "sudroid";
  public static boolean debug = 1;
  private static Class<?> debugClass;

  static
  {
    try
    {
      debugClass = Class.forName("android.util.Log");
      label18: return;
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      break label18;
    }
  }

  public static void d(CharSequence paramCharSequence)
  {
    if ((debug) && (!TextUtils.isEmpty(paramCharSequence)))
    {
      String str1 = TAG;
      String str2 = paramCharSequence.toString();
      Log.d(str1, str2);
    }
  }

  public static void d(CharSequence paramCharSequence, Throwable paramThrowable)
  {
    if (debug)
    {
      if (!TextUtils.isEmpty(paramCharSequence))
        break label23;
      Log.d(TAG, "", paramThrowable);
    }
    while (true)
    {
      return;
      label23: String str1 = TAG;
      String str2 = paramCharSequence.toString();
      Log.d(str1, str2, paramThrowable);
    }
  }

  public static void d(Throwable paramThrowable)
  {
    if (debug)
      d(null, paramThrowable);
  }

  public static void d(byte[] paramArrayOfByte)
  {
    if (debug)
      d(Arrays.toString(paramArrayOfByte));
  }

  public static void d(char[] paramArrayOfChar)
  {
    if (debug)
      d(Arrays.toString(paramArrayOfChar));
  }

  public static void d(double[] paramArrayOfDouble)
  {
    if (debug)
      d(Arrays.toString(paramArrayOfDouble));
  }

  public static void d(float[] paramArrayOfFloat)
  {
    if (debug)
      d(Arrays.toString(paramArrayOfFloat));
  }

  public static void d(int[] paramArrayOfInt)
  {
    if (debug)
      d(Arrays.toString(paramArrayOfInt));
  }

  public static void d(long[] paramArrayOfLong)
  {
    if (debug)
      d(Arrays.toString(paramArrayOfLong));
  }

  public static void d(Object[] paramArrayOfObject)
  {
    if (debug)
      d(Arrays.deepToString(paramArrayOfObject));
  }

  public static void d(short[] paramArrayOfShort)
  {
    if (debug)
      d(Arrays.toString(paramArrayOfShort));
  }

  public static void e(CharSequence paramCharSequence)
  {
    if ((debug) && (!TextUtils.isEmpty(paramCharSequence)))
    {
      String str1 = TAG;
      String str2 = paramCharSequence.toString();
      Log.e(str1, str2);
    }
  }

  public static void e(CharSequence paramCharSequence, Throwable paramThrowable)
  {
    if (debug)
    {
      if (!TextUtils.isEmpty(paramCharSequence))
        break label23;
      Log.e(TAG, "", paramThrowable);
    }
    while (true)
    {
      return;
      label23: String str1 = TAG;
      String str2 = paramCharSequence.toString();
      Log.e(str1, str2, paramThrowable);
    }
  }

  public static void e(Throwable paramThrowable)
  {
    if (debug)
      e(null, paramThrowable);
  }

  public static void e(byte[] paramArrayOfByte)
  {
    if (debug)
      e(Arrays.toString(paramArrayOfByte));
  }

  public static void e(char[] paramArrayOfChar)
  {
    if (debug)
      e(Arrays.toString(paramArrayOfChar));
  }

  public static void e(double[] paramArrayOfDouble)
  {
    if (debug)
      e(Arrays.toString(paramArrayOfDouble));
  }

  public static void e(float[] paramArrayOfFloat)
  {
    if (debug)
      e(Arrays.toString(paramArrayOfFloat));
  }

  public static void e(int[] paramArrayOfInt)
  {
    if (debug)
      e(Arrays.toString(paramArrayOfInt));
  }

  public static void e(long[] paramArrayOfLong)
  {
    if (debug)
      e(Arrays.toString(paramArrayOfLong));
  }

  public static void e(Object[] paramArrayOfObject)
  {
    if (debug)
      e(Arrays.deepToString(paramArrayOfObject));
  }

  public static void e(short[] paramArrayOfShort)
  {
    if (debug)
      e(Arrays.toString(paramArrayOfShort));
  }

  public static CharSequence getTag()
  {
    return TAG;
  }

  public static void i(CharSequence paramCharSequence)
  {
    if ((debug) && (!TextUtils.isEmpty(paramCharSequence)))
    {
      String str1 = TAG;
      String str2 = paramCharSequence.toString();
      Log.i(str1, str2);
    }
  }

  public static void i(CharSequence paramCharSequence, Throwable paramThrowable)
  {
    if (debug)
    {
      if (!TextUtils.isEmpty(paramCharSequence))
        break label23;
      Log.i(TAG, "", paramThrowable);
    }
    while (true)
    {
      return;
      label23: String str1 = TAG;
      String str2 = paramCharSequence.toString();
      Log.i(str1, str2, paramThrowable);
    }
  }

  public static void i(Throwable paramThrowable)
  {
    if (debug)
      i(null, paramThrowable);
  }

  public static void i(byte[] paramArrayOfByte)
  {
    if (debug)
      i(Arrays.toString(paramArrayOfByte));
  }

  public static void i(char[] paramArrayOfChar)
  {
    if (debug)
      i(Arrays.toString(paramArrayOfChar));
  }

  public static void i(double[] paramArrayOfDouble)
  {
    if (debug)
      i(Arrays.toString(paramArrayOfDouble));
  }

  public static void i(float[] paramArrayOfFloat)
  {
    if (debug)
      i(Arrays.toString(paramArrayOfFloat));
  }

  public static void i(int[] paramArrayOfInt)
  {
    if (debug)
      i(Arrays.toString(paramArrayOfInt));
  }

  public static void i(long[] paramArrayOfLong)
  {
    if (debug)
      i(Arrays.toString(paramArrayOfLong));
  }

  public static void i(Object[] paramArrayOfObject)
  {
    if (debug)
      i(Arrays.deepToString(paramArrayOfObject));
  }

  public static void i(short[] paramArrayOfShort)
  {
    if (debug)
      i(Arrays.toString(paramArrayOfShort));
  }

  public static boolean isDebug()
  {
    return debug;
  }

  public static void setDebug(boolean paramBoolean)
  {
    debug = paramBoolean;
  }

  public static void setTag(CharSequence paramCharSequence)
  {
    if (!TextUtils.isEmptyOrBlank(paramCharSequence))
      TAG = paramCharSequence.toString();
  }

  public static void v(CharSequence paramCharSequence)
  {
    if ((debug) && (!TextUtils.isEmpty(paramCharSequence)))
    {
      String str1 = TAG;
      String str2 = paramCharSequence.toString();
      Log.v(str1, str2);
    }
  }

  public static void v(CharSequence paramCharSequence, Throwable paramThrowable)
  {
    if (debug)
    {
      if (!TextUtils.isEmpty(paramCharSequence))
        break label23;
      Log.v(TAG, "", paramThrowable);
    }
    while (true)
    {
      return;
      label23: String str1 = TAG;
      String str2 = paramCharSequence.toString();
      Log.v(str1, str2, paramThrowable);
    }
  }

  public static void v(Throwable paramThrowable)
  {
    if (debug)
      v(null, paramThrowable);
  }

  public static void v(byte[] paramArrayOfByte)
  {
    if (debug)
      v(Arrays.toString(paramArrayOfByte));
  }

  public static void v(char[] paramArrayOfChar)
  {
    if (debug)
      v(Arrays.toString(paramArrayOfChar));
  }

  public static void v(double[] paramArrayOfDouble)
  {
    if (debug)
      v(Arrays.toString(paramArrayOfDouble));
  }

  public static void v(float[] paramArrayOfFloat)
  {
    if (debug)
      v(Arrays.toString(paramArrayOfFloat));
  }

  public static void v(int[] paramArrayOfInt)
  {
    if (debug)
      v(Arrays.toString(paramArrayOfInt));
  }

  public static void v(long[] paramArrayOfLong)
  {
    if (debug)
      v(Arrays.toString(paramArrayOfLong));
  }

  public static void v(Object[] paramArrayOfObject)
  {
    if (debug)
      v(Arrays.deepToString(paramArrayOfObject));
  }

  public static void v(short[] paramArrayOfShort)
  {
    if (debug)
      v(Arrays.toString(paramArrayOfShort));
  }

  public static void w(CharSequence paramCharSequence)
  {
    if ((debug) && (!TextUtils.isEmpty(paramCharSequence)))
    {
      String str1 = TAG;
      String str2 = paramCharSequence.toString();
      Log.w(str1, str2);
    }
  }

  public static void w(CharSequence paramCharSequence, Throwable paramThrowable)
  {
    if (debug)
    {
      if (!TextUtils.isEmpty(paramCharSequence))
        break label23;
      Log.w(TAG, "", paramThrowable);
    }
    while (true)
    {
      return;
      label23: String str1 = TAG;
      String str2 = paramCharSequence.toString();
      Log.w(str1, str2, paramThrowable);
    }
  }

  public static void w(Throwable paramThrowable)
  {
    if (debug)
      w(null, paramThrowable);
  }

  public static void w(byte[] paramArrayOfByte)
  {
    if (debug)
      w(Arrays.toString(paramArrayOfByte));
  }

  public static void w(char[] paramArrayOfChar)
  {
    if (debug)
      w(Arrays.toString(paramArrayOfChar));
  }

  public static void w(double[] paramArrayOfDouble)
  {
    if (debug)
      w(Arrays.toString(paramArrayOfDouble));
  }

  public static void w(float[] paramArrayOfFloat)
  {
    if (debug)
      w(Arrays.toString(paramArrayOfFloat));
  }

  public static void w(int[] paramArrayOfInt)
  {
    if (debug)
      w(Arrays.toString(paramArrayOfInt));
  }

  public static void w(long[] paramArrayOfLong)
  {
    if (debug)
      w(Arrays.toString(paramArrayOfLong));
  }

  public static void w(Object[] paramArrayOfObject)
  {
    if (debug)
      w(Arrays.deepToString(paramArrayOfObject));
  }

  public static void w(short[] paramArrayOfShort)
  {
    if (debug)
      w(Arrays.toString(paramArrayOfShort));
  }

  class Log
  {
    static void d(String paramString1, String paramString2)
    {
      if (LogUtils.debugClass != null);
      while (true)
      {
        try
        {
          Class localClass1 = LogUtils.debugClass;
          Class[] arrayOfClass = new Class[2];
          arrayOfClass[0] = String.class;
          arrayOfClass[1] = String.class;
          Method localMethod = localClass1.getMethod("d", arrayOfClass);
          Class localClass2 = LogUtils.debugClass;
          Object[] arrayOfObject = new Object[2];
          arrayOfObject[0] = paramString1;
          arrayOfObject[1] = paramString2;
          Object localObject = localMethod.invoke(localClass2, arrayOfObject);
          return;
        }
        catch (Exception localException)
        {
        }
        PrintStream localPrintStream = System.out;
        String str1 = String.valueOf(paramString1);
        String str2 = str1 + " -- " + paramString2;
        localPrintStream.println(str2);
      }
    }

    static void d(String paramString1, String paramString2, Throwable paramThrowable)
    {
      if (LogUtils.debugClass != null);
      while (true)
      {
        try
        {
          Class localClass1 = LogUtils.debugClass;
          Class[] arrayOfClass = new Class[3];
          arrayOfClass[0] = String.class;
          arrayOfClass[1] = String.class;
          arrayOfClass[2] = Throwable.class;
          Method localMethod = localClass1.getMethod("d", arrayOfClass);
          Class localClass2 = LogUtils.debugClass;
          Object[] arrayOfObject = new Object[3];
          arrayOfObject[0] = paramString1;
          arrayOfObject[1] = paramString2;
          arrayOfObject[2] = paramThrowable;
          Object localObject = localMethod.invoke(localClass2, arrayOfObject);
          return;
        }
        catch (Exception localException)
        {
        }
        PrintStream localPrintStream1 = System.out;
        String str1 = String.valueOf(paramString1);
        String str2 = str1 + " -- " + paramString2 + " -- printStackTrance:";
        localPrintStream1.println(str2);
        PrintStream localPrintStream2 = System.out;
        paramThrowable.printStackTrace(localPrintStream2);
      }
    }

    static void e(String paramString1, String paramString2)
    {
      if (LogUtils.debugClass != null);
      while (true)
      {
        try
        {
          Class localClass1 = LogUtils.debugClass;
          Class[] arrayOfClass = new Class[2];
          arrayOfClass[0] = String.class;
          arrayOfClass[1] = String.class;
          Method localMethod = localClass1.getMethod("e", arrayOfClass);
          Class localClass2 = LogUtils.debugClass;
          Object[] arrayOfObject = new Object[2];
          arrayOfObject[0] = paramString1;
          arrayOfObject[1] = paramString2;
          Object localObject = localMethod.invoke(localClass2, arrayOfObject);
          return;
        }
        catch (Exception localException)
        {
        }
        PrintStream localPrintStream = System.err;
        String str1 = String.valueOf(paramString1);
        String str2 = str1 + " -- " + paramString2;
        localPrintStream.println(str2);
      }
    }

    static void e(String paramString1, String paramString2, Throwable paramThrowable)
    {
      if (LogUtils.debugClass != null);
      while (true)
      {
        try
        {
          Class localClass1 = LogUtils.debugClass;
          Class[] arrayOfClass = new Class[3];
          arrayOfClass[0] = String.class;
          arrayOfClass[1] = String.class;
          arrayOfClass[2] = Throwable.class;
          Method localMethod = localClass1.getMethod("e", arrayOfClass);
          Class localClass2 = LogUtils.debugClass;
          Object[] arrayOfObject = new Object[3];
          arrayOfObject[0] = paramString1;
          arrayOfObject[1] = paramString2;
          arrayOfObject[2] = paramThrowable;
          Object localObject = localMethod.invoke(localClass2, arrayOfObject);
          return;
        }
        catch (Exception localException)
        {
        }
        PrintStream localPrintStream = System.err;
        String str1 = String.valueOf(paramString1);
        String str2 = str1 + " -- " + paramString2 + " -- printStackTrance:";
        localPrintStream.println(str2);
        paramThrowable.printStackTrace();
      }
    }

    static void i(String paramString1, String paramString2)
    {
      if (LogUtils.debugClass != null);
      while (true)
      {
        try
        {
          Class localClass1 = LogUtils.debugClass;
          Class[] arrayOfClass = new Class[2];
          arrayOfClass[0] = String.class;
          arrayOfClass[1] = String.class;
          Method localMethod = localClass1.getMethod("i", arrayOfClass);
          Class localClass2 = LogUtils.debugClass;
          Object[] arrayOfObject = new Object[2];
          arrayOfObject[0] = paramString1;
          arrayOfObject[1] = paramString2;
          Object localObject = localMethod.invoke(localClass2, arrayOfObject);
          return;
        }
        catch (Exception localException)
        {
        }
        PrintStream localPrintStream = System.out;
        String str1 = String.valueOf(paramString1);
        String str2 = str1 + " -- " + paramString2;
        localPrintStream.println(str2);
      }
    }

    static void i(String paramString1, String paramString2, Throwable paramThrowable)
    {
      if (LogUtils.debugClass != null);
      while (true)
      {
        try
        {
          Class localClass1 = LogUtils.debugClass;
          Class[] arrayOfClass = new Class[3];
          arrayOfClass[0] = String.class;
          arrayOfClass[1] = String.class;
          arrayOfClass[2] = Throwable.class;
          Method localMethod = localClass1.getMethod("i", arrayOfClass);
          Class localClass2 = LogUtils.debugClass;
          Object[] arrayOfObject = new Object[3];
          arrayOfObject[0] = paramString1;
          arrayOfObject[1] = paramString2;
          arrayOfObject[2] = paramThrowable;
          Object localObject = localMethod.invoke(localClass2, arrayOfObject);
          return;
        }
        catch (Exception localException)
        {
        }
        PrintStream localPrintStream = System.err;
        String str1 = String.valueOf(paramString1);
        String str2 = str1 + " -- " + paramString2 + " -- printStackTrance:";
        localPrintStream.println(str2);
        paramThrowable.printStackTrace();
      }
    }

    static void v(String paramString1, String paramString2)
    {
      if (LogUtils.debugClass != null);
      while (true)
      {
        try
        {
          Class localClass1 = LogUtils.debugClass;
          Class[] arrayOfClass = new Class[2];
          arrayOfClass[0] = String.class;
          arrayOfClass[1] = String.class;
          Method localMethod = localClass1.getMethod("v", arrayOfClass);
          Class localClass2 = LogUtils.debugClass;
          Object[] arrayOfObject = new Object[2];
          arrayOfObject[0] = paramString1;
          arrayOfObject[1] = paramString2;
          Object localObject = localMethod.invoke(localClass2, arrayOfObject);
          return;
        }
        catch (Exception localException)
        {
        }
        PrintStream localPrintStream = System.out;
        String str1 = String.valueOf(paramString1);
        String str2 = str1 + " -- " + paramString2;
        localPrintStream.println(str2);
      }
    }

    static void v(String paramString1, String paramString2, Throwable paramThrowable)
    {
      if (LogUtils.debugClass != null);
      while (true)
      {
        try
        {
          Class localClass1 = LogUtils.debugClass;
          Class[] arrayOfClass = new Class[3];
          arrayOfClass[0] = String.class;
          arrayOfClass[1] = String.class;
          arrayOfClass[2] = Throwable.class;
          Method localMethod = localClass1.getMethod("v", arrayOfClass);
          Class localClass2 = LogUtils.debugClass;
          Object[] arrayOfObject = new Object[3];
          arrayOfObject[0] = paramString1;
          arrayOfObject[1] = paramString2;
          arrayOfObject[2] = paramThrowable;
          Object localObject = localMethod.invoke(localClass2, arrayOfObject);
          return;
        }
        catch (Exception localException)
        {
        }
        PrintStream localPrintStream = System.err;
        String str1 = String.valueOf(paramString1);
        String str2 = str1 + " -- " + paramString2 + " -- printStackTrance:";
        localPrintStream.println(str2);
        paramThrowable.printStackTrace();
      }
    }

    static void w(String paramString1, String paramString2)
    {
      if (LogUtils.debugClass != null);
      while (true)
      {
        try
        {
          Class localClass1 = LogUtils.debugClass;
          Class[] arrayOfClass = new Class[2];
          arrayOfClass[0] = String.class;
          arrayOfClass[1] = String.class;
          Method localMethod = localClass1.getMethod("w", arrayOfClass);
          Class localClass2 = LogUtils.debugClass;
          Object[] arrayOfObject = new Object[2];
          arrayOfObject[0] = paramString1;
          arrayOfObject[1] = paramString2;
          Object localObject = localMethod.invoke(localClass2, arrayOfObject);
          return;
        }
        catch (Exception localException)
        {
        }
        PrintStream localPrintStream = System.out;
        String str1 = String.valueOf(paramString1);
        String str2 = str1 + " -- " + paramString2;
        localPrintStream.println(str2);
      }
    }

    static void w(String paramString1, String paramString2, Throwable paramThrowable)
    {
      if (LogUtils.debugClass != null);
      while (true)
      {
        try
        {
          Class localClass1 = LogUtils.debugClass;
          Class[] arrayOfClass = new Class[3];
          arrayOfClass[0] = String.class;
          arrayOfClass[1] = String.class;
          arrayOfClass[2] = Throwable.class;
          Method localMethod = localClass1.getMethod("w", arrayOfClass);
          Class localClass2 = LogUtils.debugClass;
          Object[] arrayOfObject = new Object[3];
          arrayOfObject[0] = paramString1;
          arrayOfObject[1] = paramString2;
          arrayOfObject[2] = paramThrowable;
          Object localObject = localMethod.invoke(localClass2, arrayOfObject);
          return;
        }
        catch (Exception localException)
        {
        }
        PrintStream localPrintStream = System.err;
        String str1 = String.valueOf(paramString1);
        String str2 = str1 + " -- " + paramString2 + " -- printStackTrance:";
        localPrintStream.println(str2);
        paramThrowable.printStackTrace();
      }
    }
  }
}

/* Location:           D:\Program Files\eclipse\apktool-r01-3\新浪微博\classes.dex.dex2jar.jar
 * Qualified Name:     sudroid.LogUtils
 * JD-Core Version:    0.6.0
 */